{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "c31f62e6-7593-4975-ac72-c8d1a59fe3b7",
        "showInput": false
      },
      "source": [
        "## Constraint Active Search for Multiobjective Experimental Design\n",
        "\n",
        "In this tutorial we show how to implement the Expected Coverage Improvement (ECI) [1] acquisition function in BoTorch. For a number of outcome constraints, ECI tries to efficiently discover the feasible region and simultaneously sample diverse feasible configurations. Given a user-specified punchout radius $r$, we center a sphere with that radius around each evaluated configuration. The total coverage is now given by the volume of the union of these sphere intersected with the feasible region; see the paper and, in particular, Figure 2 for a full description of how ECI works.\n",
        "\n",
        "By design, ECI prefers candidates that are in unexplored regions since the candidate's corresponding sphere won't intersect with the spheres around the previously evaluated configurations. On the other hand, ECI also prefers configurations that are likely to satisfy the constraints and to give an improvement in the total coverage. This results in an exploitation-exploration trade-off similar to other acquisition functions.\n",
        "\n",
        "ECI may be estimated using the following equation:\n",
        "$$\n",
        "\\text{ECI}(x) = \\sum_{x' \\in \\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)} p(Z(x') = 1 \\;|\\; \\mathcal{D}_t).\n",
        "$$\n",
        "\n",
        "where $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$ a set of points generated via Monte Carlo to be inside a sphere of radius $r$ around $x$, but sufficiently far from the set of known evaluations $X$ (where sufficiently far is defined by the punchout radius $r$). The function $p(Z(x') = 1 \\;|\\; \\mathcal{D}_t)$ is the probability that the GP at $x'$ satisfies a user-specified threshold value, or threshold values in the case of multiple objective functions. \n",
        "\n",
        "[1]: [Malkomes et al., Beyond the Pareto Efficient Frontier: Constraint Active Search for Multiobjective Experimental Design, Proceedings of the 38th International Conference on Machine Learning, 2021](http://proceedings.mlr.press/v139/malkomes21a/malkomes21a.pdf)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Install dependencies if we are running in colab\n",
        "import sys\n",
        "if 'google.colab' in sys.modules:\n",
        "    %pip install botorch"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489228284,
        "executionStopTime": 1638489229640,
        "hidden_ranges": [],
        "originalKey": "9896cb02-0d0e-498f-bdf7-86ea14baaf40",
        "requestMsgId": "9896cb02-0d0e-498f-bdf7-86ea14baaf40"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "\n",
        "import torch\n",
        "from botorch.acquisition.monte_carlo import MCAcquisitionFunction\n",
        "from botorch.acquisition.objective import IdentityMCObjective\n",
        "from botorch.fit import fit_gpytorch_mll\n",
        "from botorch.models import ModelListGP, SingleTaskGP\n",
        "from botorch.optim import optimize_acqf\n",
        "from botorch.utils.sampling import sample_hypersphere\n",
        "from botorch.utils.transforms import average_over_ensemble_models, t_batch_mode_transform\n",
        "from gpytorch.constraints import Interval\n",
        "from gpytorch.likelihoods import GaussianLikelihood\n",
        "from gpytorch.mlls import ExactMarginalLogLikelihood\n",
        "from torch.quasirandom import SobolEngine\n",
        "\n",
        "\n",
        "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489229684,
        "executionStopTime": 1638489230490,
        "hidden_ranges": [],
        "originalKey": "b4b78cb1-b0d4-4203-a97b-7a293ea418d4",
        "requestMsgId": "b4b78cb1-b0d4-4203-a97b-7a293ea418d4"
      },
      "outputs": [],
      "source": [
        "tkwargs = {\n",
        "    \"device\": torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\"),\n",
        "    \"dtype\": torch.double,\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "e9cecfd7-f548-4b66-8009-c97809afc144",
        "showInput": false
      },
      "source": [
        "To start, we need to be able to sample points in $\\mathbb{N}(x) \\setminus \\mathbb{N}_{r}(X)$. We can generate a pool of points and use standard rejection sampling to do so, but this leads to an acquisition function that isn't immediately differentiable; rejection sampling is essentially providing either a binary weight of either 0 or 1 to each point in the sample pool, which is not a differentiable function. \n",
        "\n",
        "\n",
        "In order to make the acquisition function differentiable, we rely on a differentiable approximation of this binary weight function. For example, `smooth_box_mask` is a continuous differentiable approximation of $a < x < b$ (see the plot below for a visualization). A larger value of eps will make the sigmoid less steep and result in a smoother (and easier to optimize) but less accurate acquisition function. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "executionStartTime": 1638489230493,
        "executionStopTime": 1638489230509,
        "originalKey": "63c0a300-c3a1-49bb-a6ba-41cf9dfa9632",
        "requestMsgId": "63c0a300-c3a1-49bb-a6ba-41cf9dfa9632"
      },
      "outputs": [],
      "source": [
        "def smooth_mask(x, a, eps=2e-3):\n",
        "    \"\"\"Returns 0ish for x < a and 1ish for x > a\"\"\"\n",
        "    return torch.nn.Sigmoid()((x - a) / eps)\n",
        "\n",
        "\n",
        "def smooth_box_mask(x, a, b, eps=2e-3):\n",
        "    \"\"\"Returns 1ish for a < x < b and 0ish otherwise\"\"\"\n",
        "    return smooth_mask(x, a, eps) - smooth_mask(x, b, eps)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489230587,
        "executionStopTime": 1638489233802,
        "hidden_ranges": [],
        "originalKey": "7b49f71b-f131-4600-96fd-5aa581212202",
        "requestMsgId": "7b49f71b-f131-4600-96fd-5aa581212202"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x400 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "%matplotlib inline\n",
        "\n",
        "\n",
        "x = torch.linspace(-2, 2, 500, **tkwargs)\n",
        "\n",
        "fig, ax = plt.subplots(1, 2, figsize=(8, 4))\n",
        "ax[0].plot(x.cpu(), smooth_mask(x, -1).cpu(), \"b\")\n",
        "ax[1].plot(x.cpu(), smooth_box_mask(x, -1, 1).cpu(), \"b\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "7ff5ed82-355b-45b8-91f9-823c41c46efc",
        "showInput": false
      },
      "source": [
        "## Implementation of ECI\n",
        "\n",
        "Once we have defined our smooth mask functions, we can compute a differentiable approximation of ECI in a straightforward manner using Monte Carlo (MC). We use the popular variance reduction technique of Common random numbers (CRN).\n",
        "\n",
        "We first use a low discrepancy sequence to generate a set of base samples. We integrate (sum) over these base samples to approximate the ECI acquisition function. Fixing these base samples makes the method deterministic and by using the smooth masks defined earlier, we can filter out infeasible points while still having a differentiable acquisition function.\n",
        "\n",
        "This implementation assumes that the GP models for the different outputs are independent and that each constraints only affects one output (simple box-constraints like f(x) <= 0.5)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489233910,
        "executionStopTime": 1638489233950,
        "hidden_ranges": [],
        "originalKey": "5dd0a6af-0bde-4e57-8bdd-d53baea75075",
        "requestMsgId": "5dd0a6af-0bde-4e57-8bdd-d53baea75075"
      },
      "outputs": [],
      "source": [
        "class ExpectedCoverageImprovement(MCAcquisitionFunction):\n",
        "    def __init__(\n",
        "        self,\n",
        "        model,\n",
        "        constraints,\n",
        "        punchout_radius,\n",
        "        bounds,\n",
        "        num_samples=128,\n",
        "        **kwargs,\n",
        "    ):\n",
        "        \"\"\"Expected Coverage Improvement (q=1 required, analytic)\n",
        "\n",
        "        Right now, we assume that all the models in the ModelListGP have\n",
        "        the same training inputs.\n",
        "\n",
        "        Args:\n",
        "            model: A ModelListGP object containing models matching the corresponding constraints.\n",
        "                All models are assumed to have the same training data.\n",
        "            constraints: List containing 2-tuples with (direction, value), e.g.,\n",
        "                [('gt', 3), ('lt', 4)]. It is necessary that\n",
        "                len(constraints) == model.num_outputs.\n",
        "            punchout_radius: Positive value defining the desired minimum distance between points\n",
        "            bounds: torch.tensor whose first row is the lower bounds and second row is the upper bounds\n",
        "            num_samples: Number of samples for MC integration\n",
        "        \"\"\"\n",
        "        super().__init__(model=model, objective=IdentityMCObjective(), **kwargs)\n",
        "        assert len(constraints) == model.num_outputs\n",
        "        assert all(direction in (\"gt\", \"lt\") for direction, _ in constraints)\n",
        "        assert punchout_radius > 0\n",
        "        self.constraints = constraints\n",
        "        self.punchout_radius = punchout_radius\n",
        "        self.bounds = bounds\n",
        "        self.base_points = self.train_inputs\n",
        "        self.ball_of_points = self._generate_ball_of_points(\n",
        "            num_samples=num_samples,\n",
        "            radius=punchout_radius,\n",
        "            device=bounds.device,\n",
        "            dtype=bounds.dtype,\n",
        "        )\n",
        "        self._thresholds = torch.tensor(\n",
        "            [threshold for _, threshold in self.constraints]\n",
        "        ).to(bounds)\n",
        "        assert (\n",
        "            all(ub > lb for lb, ub in self.bounds.T) and len(self.bounds.T) == self.dim\n",
        "        )\n",
        "\n",
        "    @property\n",
        "    def num_outputs(self):\n",
        "        return self.model.num_outputs\n",
        "\n",
        "    @property\n",
        "    def dim(self):\n",
        "        return self.train_inputs.shape[-1]\n",
        "\n",
        "    @property\n",
        "    def train_inputs(self):\n",
        "        return self.model.models[0].train_inputs[0]\n",
        "\n",
        "    def _generate_ball_of_points(\n",
        "        self, num_samples, radius, device=None, dtype=torch.double\n",
        "    ):\n",
        "        \"\"\"Creates a ball of points to be used for MC.\"\"\"\n",
        "        tkwargs = {\"device\": device, \"dtype\": dtype}\n",
        "        z = sample_hypersphere(d=self.dim, n=num_samples, qmc=True, **tkwargs)\n",
        "        r = torch.rand(num_samples, 1, **tkwargs) ** (1 / self.dim)\n",
        "        return radius * r * z\n",
        "\n",
        "    def _get_base_point_mask(self, X):\n",
        "        distance_matrix = self.model.models[0].covar_module.covar_dist(\n",
        "            X, self.base_points\n",
        "        )\n",
        "        return smooth_mask(distance_matrix, self.punchout_radius)\n",
        "\n",
        "    def _estimate_probabilities_of_satisfaction_at_points(self, points):\n",
        "        \"\"\"Estimate the probability of satisfying the given constraints.\"\"\"\n",
        "        posterior = self.model.posterior(X=points)\n",
        "        mus, sigma2s = posterior.mean, posterior.variance\n",
        "        dist = torch.distributions.normal.Normal(mus, sigma2s.sqrt())\n",
        "        norm_cdf = dist.cdf(self._thresholds)\n",
        "        probs = torch.ones(points.shape[:-1]).to(points)\n",
        "        for i, (direction, _) in enumerate(self.constraints):\n",
        "            probs = probs * (\n",
        "                norm_cdf[..., i] if direction == \"lt\" else 1 - norm_cdf[..., i]\n",
        "            )\n",
        "        return probs\n",
        "\n",
        "    @t_batch_mode_transform(expected_q=1)\n",
        "    @average_over_ensemble_models\n",
        "    def forward(self, X):\n",
        "        \"\"\"Evaluate Expected Improvement on the candidate set X.\"\"\"\n",
        "        ball_around_X = self.ball_of_points + X\n",
        "        domain_mask = smooth_box_mask(\n",
        "            ball_around_X, self.bounds[0, :], self.bounds[1, :]\n",
        "        ).prod(dim=-1)\n",
        "        num_points_in_integral = domain_mask.sum(dim=-1)\n",
        "        base_point_mask = self._get_base_point_mask(ball_around_X).prod(dim=-1)\n",
        "        prob = self._estimate_probabilities_of_satisfaction_at_points(ball_around_X)\n",
        "        masked_prob = prob * domain_mask * base_point_mask\n",
        "        y = masked_prob.sum(dim=-1) / num_points_in_integral\n",
        "        return y"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489234035,
        "executionStopTime": 1638489234089,
        "hidden_ranges": [],
        "originalKey": "b56e4297-9927-4a5e-aa8f-f5e93181e44d",
        "requestMsgId": "b56e4297-9927-4a5e-aa8f-f5e93181e44d"
      },
      "outputs": [],
      "source": [
        "def get_and_fit_gp(X, Y):\n",
        "    \"\"\"Simple method for creating a GP with one output dimension.\n",
        "\n",
        "    X is assumed to be in [0, 1]^d.\n",
        "    \"\"\"\n",
        "    assert Y.ndim == 2 and Y.shape[-1] == 1\n",
        "    likelihood = GaussianLikelihood(noise_constraint=Interval(1e-6, 1e-3))  # Noise-free\n",
        "    gp = SingleTaskGP(X, Y, likelihood=likelihood)\n",
        "    mll = ExactMarginalLogLikelihood(model=gp, likelihood=gp.likelihood)\n",
        "    fit_gpytorch_mll(mll)\n",
        "    return gp"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "e7c7c1b3-249f-4e32-b8b7-3c7e737e82b2",
        "showInput": false
      },
      "source": [
        "### Simple 1D function\n",
        "\n",
        "To sanity check things, we consider the ECI acquisition function on a one-dimensional toy problem. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "executionStartTime": 1638489234145,
        "executionStopTime": 1638489234200,
        "originalKey": "cc435c3c-c65f-4446-a33e-fd5cda030962",
        "requestMsgId": "cc435c3c-c65f-4446-a33e-fd5cda030962"
      },
      "outputs": [],
      "source": [
        "def yf(x):\n",
        "    return (1 - torch.exp(-4 * (x[:, 0] - 0.4) ** 2)).unsqueeze(-1)\n",
        "\n",
        "\n",
        "x = torch.tensor([0, 0.15, 0.25, 0.4, 0.8, 1.0], **tkwargs).unsqueeze(-1)\n",
        "y = yf(x)\n",
        "xx = torch.linspace(0, 1, 200, **tkwargs).unsqueeze(-1)\n",
        "yy = yf(xx)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "8bbfe7b8-b758-424a-b6bc-f2c91f8b1e95",
        "showInput": false
      },
      "source": [
        "### Create an ECI acquisition function\n",
        "Our implementation assumes that the GP is passed in as a `ModelListGP` and that the GPs match the corresponding constraints. As an example, assume we have two outputs, represented by `gp1` and `gp2` and two constraints corresponding to output 1 and a third constraint corresponding to output 2. In that case we will create a model list GP as `ModelListGP(gp1, gp1, gp2)` so they match the constraints."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489234253,
        "executionStopTime": 1638489235584,
        "hidden_ranges": [],
        "originalKey": "9efe991c-8256-4c7c-b61f-8abb5d258d40",
        "requestMsgId": "9efe991c-8256-4c7c-b61f-8abb5d258d40"
      },
      "outputs": [],
      "source": [
        "gp = get_and_fit_gp(x, y)\n",
        "model_list_gp = ModelListGP(gp, gp)\n",
        "constraints = [(\"lt\", 0.3), (\"gt\", 0.05)]\n",
        "punchout_radius = 0.03\n",
        "bounds = torch.tensor([(0, 1)], **tkwargs).T\n",
        "eci = ExpectedCoverageImprovement(\n",
        "    model=model_list_gp,\n",
        "    constraints=constraints,\n",
        "    punchout_radius=punchout_radius,\n",
        "    bounds=bounds,\n",
        "    num_samples=128 if not SMOKE_TEST else 4,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "f1cfa2a0-db3f-49a2-b32f-6fad380b0c3e",
        "showInput": false
      },
      "source": [
        "### Optimize the acquisition function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489235787,
        "executionStopTime": 1638489236864,
        "hidden_ranges": [],
        "originalKey": "1ae10691-8d4e-40e7-8c32-f15a35ddf590",
        "requestMsgId": "1ae10691-8d4e-40e7-8c32-f15a35ddf590",
        "showInput": true
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Best candidate: 0.622\n"
          ]
        }
      ],
      "source": [
        "best_candidate, best_eci_value = optimize_acqf(\n",
        "    acq_function=eci,\n",
        "    bounds=torch.tensor([[0.0], [1.0]], **tkwargs),\n",
        "    q=1,\n",
        "    num_restarts=10,\n",
        "    raw_samples=20,  # use a small number here to make sure the optimization works\n",
        ")\n",
        "print(f\"Best candidate: {best_candidate.cpu().item():.3f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "15a4d7cf-be03-4e52-9792-e3a680f37bb7",
        "showInput": false
      },
      "source": [
        "### Plot the GP and the ECI acquisition function\n",
        "The left plot shows the GP posterior with a 95% confidence interval. The two horizontal lines indicate the feasible region defined by $0.05 \\leq f(x) \\leq 0.3$. These inequality constraints implicitly define a feasible region, outside which ECI has value zero. \n",
        "\n",
        "We can see in the right plot that ECI indeed has a nonzero value inside the feasible region and a zero value outside. We also optimize the acquisition function and mark its argmax with black star; the argmax is around $x=0.62$. This is reasonable because ECI seeks to select diverse points within the feasible region. $x=0.62$ is far away from other evaluations and thus has the highest diversity. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489236964,
        "executionStopTime": 1638489237535,
        "hidden_ranges": [],
        "originalKey": "5f5b4b6a-4d53-4528-8420-53e4f9358f5c",
        "requestMsgId": "5f5b4b6a-4d53-4528-8420-53e4f9358f5c"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1200x500 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "with torch.no_grad():\n",
        "    posterior = gp.posterior(X=xx.unsqueeze(1))\n",
        "ymean, yvar = posterior.mean.squeeze(-1), posterior.variance.squeeze(-1)\n",
        "eci_vals = eci(xx.unsqueeze(1))\n",
        "\n",
        "fig, axes = plt.subplots(1, 2, figsize=(12, 5))\n",
        "ax = axes[0]\n",
        "ax.plot(xx[:, 0].cpu(), ymean[:, 0].cpu(), \"b\")\n",
        "ax.fill_between(\n",
        "    xx[:, 0].cpu(),\n",
        "    ymean[:, 0].cpu() - 1.96 * yvar[:, 0].sqrt().cpu(),\n",
        "    ymean[:, 0].cpu() + 1.96 * yvar[:, 0].sqrt().cpu(),\n",
        "    alpha=0.1,\n",
        "    color=\"b\",\n",
        ")\n",
        "ax.plot(x[:, 0].cpu(), y[:, 0].cpu(), \"or\")\n",
        "ax.axhline(0.05, 0, 1)\n",
        "ax.axhline(0.3, 0, 1)\n",
        "\n",
        "ax = axes[1]\n",
        "ax.plot(xx[:, 0].cpu(), eci_vals.detach().cpu())\n",
        "ax.plot(x[:, 0].cpu(), torch.zeros(len(x), **tkwargs).cpu(), \"or\")\n",
        "ax.plot(best_candidate.cpu(), best_eci_value.cpu(), \"*k\", ms=10)\n",
        "ax.set_title(\"ECI\", fontsize=14)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "33ea647e-bdaf-4264-ab65-3e6df4ba8c6e",
        "showInput": false
      },
      "source": [
        "## Full 2D CAS-loop \n",
        "This creates a simple function with two outputs that we will consider under the two constraints $f_1(x) \\leq 0.75$ and $f_2(x) \\geq 0.55$. In this particular example, the $f_1(x)$ and $f_2(x)$ are same function for simplicity. \n",
        "\n",
        "The CAS loop follows the prototypical BO loop: \n",
        "1. Given a surrogate model, maximize ECI to select the next evaluation x.\n",
        "2. Observe f(x).\n",
        "3. Update the surrogate model. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489237543,
        "executionStopTime": 1638489237685,
        "hidden_ranges": [],
        "originalKey": "691460ed-a2c8-45b5-8dc9-c6d8c87ee9d7",
        "requestMsgId": "691460ed-a2c8-45b5-8dc9-c6d8c87ee9d7"
      },
      "outputs": [],
      "source": [
        "def yf2d(x):\n",
        "    v = torch.exp(-2 * (x[:, 0] - 0.3) ** 2 - 4 * (x[:, 1] - 0.6) ** 2)\n",
        "    return torch.stack((v, v), dim=-1)\n",
        "\n",
        "\n",
        "bounds = torch.tensor([[0, 0], [1, 1]], **tkwargs)\n",
        "lb, ub = bounds\n",
        "dim = len(lb)\n",
        "constraints = [(\"lt\", 0.75), (\"gt\", 0.55)]\n",
        "punchout_radius = 0.1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "originalKey": "6f354b25-8703-4156-908d-d53c1c2bbe4a",
        "showInput": false
      },
      "source": [
        "### CAS loop using 5 initial Sobol points and 15 ECI iterations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489237803,
        "executionStopTime": 1638489266352,
        "hidden_ranges": [],
        "originalKey": "6d77353b-8dda-4835-9c6a-b0a53fddc67c",
        "requestMsgId": "6d77353b-8dda-4835-9c6a-b0a53fddc67c"
      },
      "outputs": [],
      "source": [
        "num_init_points = 5\n",
        "num_total_points = 15 if not SMOKE_TEST else 5\n",
        "\n",
        "X = lb + (ub - lb) * SobolEngine(dim, scramble=True).draw(num_init_points).to(**tkwargs)\n",
        "Y = yf2d(X)\n",
        "\n",
        "while len(X) < num_total_points:\n",
        "    # We don't have to normalize X since the domain is [0, 1]^2. Make sure to\n",
        "    # appropriately adjust the punchout radius if the domain is normalized.\n",
        "    gp_models = [get_and_fit_gp(X, Y[:, i : i + 1]) for i in range(Y.shape[-1])]\n",
        "    model_list_gp = ModelListGP(gp_models[0], gp_models[1])\n",
        "    eci = ExpectedCoverageImprovement(\n",
        "        model=model_list_gp,\n",
        "        constraints=constraints,\n",
        "        punchout_radius=punchout_radius,\n",
        "        bounds=bounds,\n",
        "        num_samples=128 if not SMOKE_TEST else 4,\n",
        "    )\n",
        "    x_next, _ = optimize_acqf(\n",
        "        acq_function=eci,\n",
        "        bounds=bounds,\n",
        "        q=1,\n",
        "        num_restarts=10 if not SMOKE_TEST else 2,\n",
        "        raw_samples=512 if not SMOKE_TEST else 4,\n",
        "    )\n",
        "    y_next = yf2d(x_next)\n",
        "    X = torch.cat((X, x_next))\n",
        "    Y = torch.cat((Y, y_next))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "code_folding": [],
        "hidden_ranges": [],
        "originalKey": "255bba4f-4d9a-46cc-aa66-16b90287824a",
        "showInput": false
      },
      "source": [
        "### Plot the selected points\n",
        "We plot the feasible region and the points selected by ECI below. The feasible region is outlined with a black ring, and points selected by ECI are marked in green (feasible) and red (infeasible). By design, observe that ECI selects a diverse i.e., well-spaced set of points inside the feasible region. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "code_folding": [],
        "customInput": null,
        "executionStartTime": 1638489266464,
        "executionStopTime": 1638489266516,
        "hidden_ranges": [],
        "originalKey": "6b62af84-01c0-4971-9122-bd5f01b9f31b",
        "requestMsgId": "6b62af84-01c0-4971-9122-bd5f01b9f31b",
        "showInput": true
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/opt/miniconda3/lib/python3.12/site-packages/torch/functional.py:534: UserWarning: torch.meshgrid: in an upcoming release, it will be required to pass the indexing argument. (Triggered internally at /Users/runner/work/_temp/anaconda/conda-bld/pytorch_1729646995093/work/aten/src/ATen/native/TensorShape.cpp:3596.)\n",
            "  return _VF.meshgrid(tensors, **kwargs)  # type: ignore[attr-defined]\n"
          ]
        }
      ],
      "source": [
        "N1, N2 = 30, 30\n",
        "Xplt, Yplt = torch.meshgrid(\n",
        "    torch.linspace(0, 1, N1, **tkwargs), torch.linspace(0, 1, N2, **tkwargs)\n",
        ")\n",
        "xplt = torch.stack(\n",
        "    (\n",
        "        torch.reshape(Xplt, (Xplt.shape[0] * Xplt.shape[1],)),\n",
        "        torch.reshape(Yplt, (Yplt.shape[0] * Yplt.shape[1],)),\n",
        "    ),\n",
        "    dim=1,\n",
        ")\n",
        "yplt = yf2d(xplt)\n",
        "Zplt = torch.reshape(yplt[:, 0], (N1, N2))  # Since f1(x) = f2(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "code_folding": [],
        "executionStartTime": 1638489266564,
        "executionStopTime": 1638489267143,
        "hidden_ranges": [],
        "originalKey": "a44c258c-0373-4c68-9887-9ae7a57bcccc",
        "requestMsgId": "a44c258c-0373-4c68-9887-9ae7a57bcccc"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "def identify_samples_which_satisfy_constraints(X, constraints):\n",
        "    \"\"\"\n",
        "    Takes in values (a1, ..., ak, o) and returns (a1, ..., ak, o)\n",
        "    True/False values, where o is the number of outputs.\n",
        "    \"\"\"\n",
        "    successful = torch.ones(X.shape).to(X)\n",
        "    for model_index in range(X.shape[-1]):\n",
        "        these_X = X[..., model_index]\n",
        "        direction, value = constraints[model_index]\n",
        "        successful[..., model_index] = (\n",
        "            these_X < value if direction == \"lt\" else these_X > value\n",
        "        )\n",
        "    return successful\n",
        "\n",
        "\n",
        "fig, ax = plt.subplots(figsize=(8, 6))\n",
        "h1 = ax.contourf(Xplt.cpu().numpy(), Yplt.cpu().numpy(), Zplt.cpu().numpy(), 20, cmap=\"Blues\", alpha=0.6)\n",
        "fig.colorbar(h1)\n",
        "ax.contour(Xplt.cpu().numpy(), Yplt.cpu().numpy(), Zplt.cpu().numpy(), [0.55, 0.75], colors=\"k\")\n",
        "\n",
        "feasible_inds = (\n",
        "    identify_samples_which_satisfy_constraints(Y, constraints)\n",
        "    .prod(dim=-1)\n",
        "    .to(torch.bool)\n",
        ")\n",
        "ax.plot(X[feasible_inds, 0].cpu(), X[feasible_inds, 1].cpu(), \"sg\", label=\"Feasible\")\n",
        "ax.plot(\n",
        "    X[~feasible_inds, 0].cpu(), X[~feasible_inds, 1].cpu(), \"sr\", label=\"Infeasible\"\n",
        ")\n",
        "\n",
        "ax.legend(loc=[0.7, 0.05])\n",
        "ax.set_title(\"$f_1(x)$\")  # Recall that f1(x) = f2(x)\n",
        "ax.set_xlabel(\"$x_1$\")\n",
        "ax.set_ylabel(\"$x_2$\")\n",
        "ax.set_aspect(\"equal\", \"box\")\n",
        "ax.set_xlim([-0.05, 1.05])\n",
        "ax.set_ylim([-0.05, 1.05])\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "executionStartTime": 1638489267152,
        "executionStopTime": 1638489267253,
        "originalKey": "0ff4a95d-b556-4a21-b794-184ba4181a49",
        "requestMsgId": "0ff4a95d-b556-4a21-b794-184ba4181a49"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "fileHeader": "",
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12.2"
    }
  },
  "nbformat": 4,
 "nbformat_minor": 4
}
